package com.gxc.graph;

import java.util.Scanner;
import java.util.Stack;

/**
 * 有一个大小是N*M的战场地图，被墙壁 ‘#’ 分隔成大小不同的区域，上下左右四个方向相邻的空地 ‘.’ 属于同一个区域，只有空地上可能存在敌人’E”，
 *
 * 请求出地图上总共有多少区域里的敌人数小于K。
 *
 * 输入描述
 * 第一行输入为N,M,K；
 *
 * N表示地图的行数，M表示地图的列数， K表示目标敌人数量
 * N，M<=100
 * 之后为一个NxM大小的字符数组。
 *
 * 输出描述
 * 敌人数小于K的区域数量
 */
public class Enemy {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int k = scanner.nextInt();
        scanner.nextLine();
        char[][] array = new char[n][m];
        int[][] visit = new int[n][m];
        for (int i = 0; i < array.length; i++) {
            String str = scanner.next();
            for (int j = 0; j < array[i].length; j++) {
                array[i][j] = str.charAt(j);
            }
        }
        scanner.close();;

        int res = 0;
        int[][] directions = new int[][]{{-1, 0},{1, 0},{0, -1},{0, 1}};
        Stack<int[]> stack = new Stack<>();
        for (int i = 0; i < visit.length; i++) {
            for (int j = 0; j < visit[i].length; j++) {
                if (array[i][j] == '#') {
                    visit[i][j] = 1;
                } else {
                    if (visit[i][j] == 0) {
                        int count = 0;
                        boolean flag = false;
                        stack.push(new int[]{i, j});
                        while (!stack.isEmpty()) {
                            int[] pop = stack.pop();
                            int x = pop[0];
                            int y = pop[1];
                            if (visit[x][y] == 1) continue;
                            //已访问
                            visit[x][y] = 1;
                            if (array[x][y] == 'E') {
                                count++;
                                flag = true;
                            }
                            for (int o = 0; o < directions.length; o++) {
                                int[] direction = directions[o];
                                int newx = x + direction[0];
                                int newy = y + direction[1];
                                //未访问
                                if (newx>=0 && newx<n && newy>=0 && newy<m && visit[newx][newy] == 0 && array[newx][newy]!='#') {
                                    stack.push(new int[]{newx, newy});
                                }
                            }
                        }
                        if (count < k && flag) {
                            res++;
                        }
                    }
                }
            }
        }
        System.out.println(res);
    }

    // 定义地图的行数、列数和目标敌人数量
    private static int n, m, k;
    // 定义存储地图的二维字符数组
    private static char[][] matrix;
    // 定义标记访问状态的二维数组
    private static int[][] visited;
    // 记录当前区域的敌人数量
    private static int enemyCount;

    public static void main2(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 读取地图的行数n、列数m和目标敌人数量k
        n = scanner.nextInt();
        m = scanner.nextInt();
        k = scanner.nextInt();

        // 初始化地图矩阵和访问标记数组
        matrix = new char[n][m];
        visited = new int[n][m];

        // 读取地图矩阵数据
        for (int i = 0; i < n; i++) {
            String row = scanner.next();
            for (int j = 0; j < m; j++) {
                matrix[i][j] = row.charAt(j); // 逐字符读取地图
            }
        }

        int ans = 0; // 初始化符合条件的区域计数

        // 遍历地图中的每个位置
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 如果当前格子已经访问过或是墙壁，跳过
                if (visited[i][j] != 0 || matrix[i][j] == '#') {
                    continue;
                }
                enemyCount = 0; // 初始化当前区域的敌人计数
                dfs(i, j); // 深度优先搜索该区域
                // 如果该区域的敌人数小于k，则该区域符合条件
                ans += enemyCount < k ? 1 : 0;
            }
        }

        // 输出符合条件的区域数量
        System.out.println(ans);
    }

    // 深度优先搜索函数，从(i, j)位置开始计算敌人数
    public static void dfs(int i, int j) {
        visited[i][j] = 1; // 将当前位置标记为已访问

        // 如果当前位置是敌人，增加敌人计数
        if (matrix[i][j] == 'E') {
            enemyCount++;
        }

        // 定义四个方向的偏移量：上、下、左、右
        int[][] offsets = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

        // 遍历四个相邻方向
        for (int[] offset : offsets) {
            int newX = i + offset[0];
            int newY = j + offset[1];

            // 检查相邻位置是否在地图范围内，未访问过且不是墙壁
            if (newX >= 0 && newX < n && newY >= 0 && newY < m && visited[newX][newY] == 0 && matrix[newX][newY] != '#') {
                dfs(newX, newY); // 递归访问相邻位置
            }
        }
    }
}
